home *** CD-ROM | disk | FTP | other *** search
/ ftp.mactech.com 2010 / ftp.mactech.com.tar / ftp.mactech.com / thinkref / archive / THINKPascalUH2.1.sea / THINKPas Univ Hdr 2.1 / Interfaces / Lists.p < prev    next >
Text File  |  1995-09-14  |  9KB  |  347 lines
  1. { Converted with MPW2TPas Tuesday, September 12, 1995 7:25:40 PM }
  2. {}
  3. {     File:        Lists.p}
  4. { }
  5. {     Contains:    List Manager Interfaces.}
  6. { }
  7. {     Version:    Technology:    System 7.5}
  8. {                 Package:    Universal Interfaces 2.1 in “MPW Latest” on ETO #18}
  9. { }
  10. {     Copyright:    © 1984-1995 by Apple Computer, Inc.}
  11. {                 All rights reserved.}
  12. { }
  13. {     Bugs?:        If you find a problem with this file, use the Apple Bug Reporter}
  14. {                 stack.  Include the file and version information (from above)}
  15. {                 in the problem description and send to:}
  16. {                     Internet:    apple.bugs@applelink.apple.com}
  17. {                     AppleLink:    APPLE.BUGS}
  18. { }
  19. {}
  20.  
  21. unit Lists;
  22. interface
  23.  
  24.  
  25. {$IFC UNDEFINED __LISTS__}
  26. {$SETC __LISTS__ := 1}
  27.  
  28.     uses
  29.         ConditionalMacros, Types, Quickdraw, Controls, Memory;
  30.  
  31. { $PUSH}
  32. { $ALIGN MAC68K}
  33. { $LibExport+}
  34. {$IFC UNDEFINED STRICT_LISTS }
  35. {$SETC STRICT_LISTS := 0}
  36. {$ENDC}
  37. {$IFC NOT STRICT_LISTS }
  38.  
  39.     const
  40.         lDoVAutoscroll = 2;
  41.         lDoHAutoscroll = 1;
  42.         lOnlyOne = -128;
  43.         lExtendDrag = 64;
  44.         lNoDisjoint = 32;
  45.         lNoExtend = 16;
  46.         lNoRect = 8;
  47.         lUseSense = 4;
  48.         lNoNilHilite = 2;
  49.  
  50.         lDoVAutoscrollBit = 1;
  51.         lDoHAutoscrollBit = 0;
  52.         lOnlyOneBit = 7;
  53.         lExtendDragBit = 6;
  54.         lNoDisjointBit = 5;
  55.         lNoExtendBit = 4;
  56.         lNoRectBit = 3;
  57.         lUseSenseBit = 2;
  58.         lNoNilHiliteBit = 1;
  59.  
  60. {$ENDC}
  61.  
  62.     const
  63.         lInitMsg = 0;
  64.         lDrawMsg = 1;
  65.         lHiliteMsg = 2;
  66.         lCloseMsg = 3;
  67.  
  68. {$IFC STRICT_LISTS }
  69.  
  70.     type
  71.         ListRef = Ptr;
  72.  
  73.         ListHandle = ListRef;
  74.  
  75. {$ELSEC}
  76.  
  77.     type
  78.         ListPtr = ^ListRec;
  79.         ListHandle = ^ListPtr;
  80.  
  81.         ListRef = ListHandle;
  82.  
  83. {$ENDC}
  84.         Cell = Point;
  85.  
  86.         ListBounds = Rect;
  87.  
  88.         DataArray = packed array[0..32000] of CHAR;
  89.  
  90.         DataPtr = ^DataArray;
  91.         DataHandle = ^DataPtr;
  92.  
  93.         ListSearchProcPtr = ProcPtr;  { FUNCTION ListSearch(aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER): INTEGER; }
  94.     {}
  95. {        ListClickLoopProcPtr uses register based parameters on the 68k and cannot}
  96. {        be written in or called from a high-level language without the help of}
  97. {        mixed mode or assembly glue.}
  98. {}
  99. {        In:}
  100. {         =>                 .?}
  101. {        Out:}
  102. {         <= return value    D0.B}
  103. {    }
  104.         ListClickLoopProcPtr = Register68kProcPtr;  { register FUNCTION ListClickLoop: BOOLEAN; }
  105.         ListSearchUPP = UniversalProcPtr;
  106.         ListClickLoopUPP = UniversalProcPtr;
  107.  
  108. {$IFC NOT STRICT_LISTS }
  109.         ListRec = record
  110.                 rView: Rect;
  111.                 port: GrafPtr;
  112.                 indent: Point;
  113.                 cellSize: Point;
  114.                 visible: ListBounds;
  115.                 vScroll: ControlRef;
  116.                 hScroll: ControlRef;
  117.                 selFlags: SInt8;
  118.                 lActive: BOOLEAN;
  119.                 lReserved: SInt8;
  120.                 listFlags: SInt8;
  121.                 clikTime: LONGINT;
  122.                 clikLoc: Point;
  123.                 mouseLoc: Point;
  124.                 lClickLoop: ListClickLoopUPP;
  125.                 lastClick: Cell;
  126.                 refCon: LONGINT;
  127.                 listDefProc: Handle;
  128.                 userHandle: Handle;
  129.                 dataBounds: ListBounds;
  130.                 cells: DataHandle;
  131.                 maxIndex: INTEGER;
  132.                 cellArray: array[0..0] of INTEGER;
  133.             end;
  134.  
  135. {$ENDC}
  136.         ListDefProcPtr = ProcPtr;  { PROCEDURE ListDef(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef); }
  137.         ListCellDrawProcPtr = ProcPtr;  { PROCEDURE ListCellDraw(lMessage: INTEGER; lSelect: BOOLEAN; VAR lRect: Rect; lCell: Cell; dataPtr: UNIV Ptr; lDataLen: INTEGER; lHandle: ListRef); }
  138.         ListDefUPP = UniversalProcPtr;
  139.         ListCellDrawUPP = UniversalProcPtr;
  140.  
  141.     const
  142.         uppListSearchProcInfo = $00002BE0; { FUNCTION (4 byte param, 4 byte param, 2 byte param, 2 byte param): 2 byte result; }
  143.         uppListClickLoopProcInfo = $00000012; { Register FUNCTION : 1 byte in D0; }
  144.         uppListDefProcInfo = $000EBD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 2 byte param, 2 byte param, 4 byte param); }
  145.         uppListCellDrawProcInfo = $000EFD80; { PROCEDURE (2 byte param, 1 byte param, 4 byte param, 4 byte param, 4 byte param, 2 byte param, 4 byte param); }
  146.  
  147.     function NewListSearchProc (userRoutine: ListSearchProcPtr): ListSearchUPP;
  148.     {$IFC NOT GENERATINGCFM }
  149.     inline
  150.         $2E9F;
  151.     {$ENDC}
  152.  
  153.     function NewListClickLoopProc (userRoutine: ListClickLoopProcPtr): ListClickLoopUPP;
  154.     {$IFC NOT GENERATINGCFM }
  155.     inline
  156.         $2E9F;
  157.     {$ENDC}
  158.  
  159.     function NewListDefProc (userRoutine: ListDefProcPtr): ListDefUPP;
  160.     {$IFC NOT GENERATINGCFM }
  161.     inline
  162.         $2E9F;
  163.     {$ENDC}
  164.  
  165.     function NewListCellDrawProc (userRoutine: ListCellDrawProcPtr): ListCellDrawUPP;
  166.     {$IFC NOT GENERATINGCFM }
  167.     inline
  168.         $2E9F;
  169.     {$ENDC}
  170.  
  171.     function CallListSearchProc (aPtr: Ptr; bPtr: Ptr; aLen: INTEGER; bLen: INTEGER; userRoutine: ListSearchUPP): INTEGER;
  172.     {$IFC NOT GENERATINGCFM}
  173.     inline
  174.         $205F, $4E90;
  175.     {$ENDC}
  176.  
  177.     function CallListClickLoopProc (userRoutine: ListClickLoopUPP): BOOLEAN;
  178.     {$IFC NOT GENERATINGCFM}
  179.     {To be implemented:  Glue to move parameters into registers.}
  180.     {$ENDC}
  181.  
  182.     procedure CallListDefProc (lMessage: INTEGER; lSelect: BOOLEAN; var lRect: Rect; lCell: Cell; lDataOffset: INTEGER; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListDefUPP);
  183.     {$IFC NOT GENERATINGCFM}
  184.     inline
  185.         $205F, $4E90;
  186.     {$ENDC}
  187.  
  188.     procedure CallListCellDrawProc (lMessage: INTEGER; lSelect: BOOLEAN; var lRect: Rect; lCell: Cell; dataPtr: univ Ptr; lDataLen: INTEGER; lHandle: ListRef; userRoutine: ListCellDrawUPP);
  189.     {$IFC NOT GENERATINGCFM}
  190.     inline
  191.         $205F, $4E90;
  192.     {$ENDC}
  193.  
  194.     function LNew ({CONST}
  195.                                     var rView: Rect; {CONST}
  196.                                     var dataBounds: ListBounds; cSize: Point; theProc: INTEGER; theWindow: WindowRef; drawIt: BOOLEAN; hasGrow: BOOLEAN; scrollHoriz: BOOLEAN; scrollVert: BOOLEAN): ListRef;
  197.     {$IFC NOT GENERATINGCFM}
  198.     inline
  199.         $3F3C, $0044, $A9E7;
  200.     {$ENDC}
  201.     procedure LDispose (lHandle: ListRef);
  202.     {$IFC NOT GENERATINGCFM}
  203.     inline
  204.         $3F3C, $0028, $A9E7;
  205.     {$ENDC}
  206.     function LAddColumn (count: INTEGER; colNum: INTEGER; lHandle: ListRef): INTEGER;
  207.     {$IFC NOT GENERATINGCFM}
  208.     inline
  209.         $3F3C, $0004, $A9E7;
  210.     {$ENDC}
  211.     function LAddRow (count: INTEGER; rowNum: INTEGER; lHandle: ListRef): INTEGER;
  212.     {$IFC NOT GENERATINGCFM}
  213.     inline
  214.         $3F3C, $0008, $A9E7;
  215.     {$ENDC}
  216.     procedure LDelColumn (count: INTEGER; colNum: INTEGER; lHandle: ListRef);
  217.     {$IFC NOT GENERATINGCFM}
  218.     inline
  219.         $3F3C, $0020, $A9E7;
  220.     {$ENDC}
  221.     procedure LDelRow (count: INTEGER; rowNum: INTEGER; lHandle: ListRef);
  222.     {$IFC NOT GENERATINGCFM}
  223.     inline
  224.         $3F3C, $0024, $A9E7;
  225.     {$ENDC}
  226.     function LGetSelect (next: BOOLEAN; var theCell: Cell; lHandle: ListRef): BOOLEAN;
  227.     {$IFC NOT GENERATINGCFM}
  228.     inline
  229.         $3F3C, $003C, $A9E7;
  230.     {$ENDC}
  231.     function LLastClick (lHandle: ListRef): Cell;
  232.     {$IFC NOT GENERATINGCFM}
  233.     inline
  234.         $3F3C, $0040, $A9E7;
  235.     {$ENDC}
  236.     function LNextCell (hNext: BOOLEAN; vNext: BOOLEAN; var theCell: Cell; lHandle: ListRef): BOOLEAN;
  237.     {$IFC NOT GENERATINGCFM}
  238.     inline
  239.         $3F3C, $0048, $A9E7;
  240.     {$ENDC}
  241.     function LSearch (dataPtr: univ Ptr; dataLen: INTEGER; searchProc: ListSearchUPP; var theCell: Cell; lHandle: ListRef): BOOLEAN;
  242.     {$IFC NOT GENERATINGCFM}
  243.     inline
  244.         $3F3C, $0054, $A9E7;
  245.     {$ENDC}
  246.     procedure LSize (listWidth: INTEGER; listHeight: INTEGER; lHandle: ListRef);
  247.     {$IFC NOT GENERATINGCFM}
  248.     inline
  249.         $3F3C, $0060, $A9E7;
  250.     {$ENDC}
  251.     procedure LSetDrawingMode (drawIt: BOOLEAN; lHandle: ListRef);
  252.     {$IFC NOT GENERATINGCFM}
  253.     inline
  254.         $3F3C, $002C, $A9E7;
  255.     {$ENDC}
  256.     procedure LScroll (dCols: INTEGER; dRows: INTEGER; lHandle: ListRef);
  257.     {$IFC NOT GENERATINGCFM}
  258.     inline
  259.         $3F3C, $0050, $A9E7;
  260.     {$ENDC}
  261.     procedure LAutoScroll (lHandle: ListRef);
  262.     {$IFC NOT GENERATINGCFM}
  263.     inline
  264.         $3F3C, $0010, $A9E7;
  265.     {$ENDC}
  266.     procedure LUpdate (theRgn: RgnHandle; lHandle: ListRef);
  267.     {$IFC NOT GENERATINGCFM}
  268.     inline
  269.         $3F3C, $0064, $A9E7;
  270.     {$ENDC}
  271.     procedure LActivate (act: BOOLEAN; lHandle: ListRef);
  272.     {$IFC NOT GENERATINGCFM}
  273.     inline
  274.         $4267, $A9E7;
  275.     {$ENDC}
  276.     procedure LCellSize (cSize: Point; lHandle: ListRef);
  277.     {$IFC NOT GENERATINGCFM}
  278.     inline
  279.         $3F3C, $0014, $A9E7;
  280.     {$ENDC}
  281.     function LClick (pt: Point; modifiers: INTEGER; lHandle: ListRef): BOOLEAN;
  282.     {$IFC NOT GENERATINGCFM}
  283.     inline
  284.         $3F3C, $0018, $A9E7;
  285.     {$ENDC}
  286.     procedure LAddToCell (dataPtr: univ Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  287.     {$IFC NOT GENERATINGCFM}
  288.     inline
  289.         $3F3C, $000C, $A9E7;
  290.     {$ENDC}
  291.     procedure LClrCell (theCell: Cell; lHandle: ListRef);
  292.     {$IFC NOT GENERATINGCFM}
  293.     inline
  294.         $3F3C, $001C, $A9E7;
  295.     {$ENDC}
  296.     procedure LGetCell (dataPtr: univ Ptr; var dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  297.     {$IFC NOT GENERATINGCFM}
  298.     inline
  299.         $3F3C, $0038, $A9E7;
  300.     {$ENDC}
  301.     procedure LRect (var cellRect: Rect; theCell: Cell; lHandle: ListRef);
  302.     {$IFC NOT GENERATINGCFM}
  303.     inline
  304.         $3F3C, $004C, $A9E7;
  305.     {$ENDC}
  306.     procedure LSetCell (dataPtr: univ Ptr; dataLen: INTEGER; theCell: Cell; lHandle: ListRef);
  307.     {$IFC NOT GENERATINGCFM}
  308.     inline
  309.         $3F3C, $0058, $A9E7;
  310.     {$ENDC}
  311.     procedure LSetSelect (setIt: BOOLEAN; theCell: Cell; lHandle: ListRef);
  312.     {$IFC NOT GENERATINGCFM}
  313.     inline
  314.         $3F3C, $005C, $A9E7;
  315.     {$ENDC}
  316.     procedure LDraw (theCell: Cell; lHandle: ListRef);
  317.     {$IFC NOT GENERATINGCFM}
  318.     inline
  319.         $3F3C, $0030, $A9E7;
  320.     {$ENDC}
  321.     procedure LGetCellDataLocation (var offset: INTEGER; var len: INTEGER; theCell: Cell; lHandle: ListRef);
  322.     {$IFC NOT GENERATINGCFM}
  323.     inline
  324.         $3F3C, $0034, $A9E7;
  325.     {$ENDC}
  326. {$IFC OLDROUTINENAMES }
  327.     procedure LDoDraw (drawIt: BOOLEAN; lHandle: ListRef);
  328.     {$IFC NOT GENERATINGCFM}
  329.     inline
  330.         $3F3C, $002C, $A9E7;
  331.     {$ENDC}
  332.     procedure LFind (var offset: INTEGER; var len: INTEGER; theCell: Cell; lHandle: ListRef);
  333.     {$IFC NOT GENERATINGCFM}
  334.     inline
  335.         $3F3C, $0034, $A9E7;
  336.     {$ENDC}
  337. {$ENDC}
  338.  
  339. { $ALIGN RESET}
  340. { $POP}
  341.  
  342. {$ENDC}
  343.  {__LISTS__}
  344.  
  345. implementation
  346. end.
  347.